package com.wtx.chapter03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @description: 流
 * @author: wtx
 * @createDate: 2020/5/31
 */
public class Test0 {
    public static void main(String[] args) {

        // 从外部迭代到内部迭代 ========================================
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++)
            list.add(i);

        //1、外部迭代
        // 当存在多重循环时, 代码可读性极差
        for (Integer i: list)
            System.out.println(i);

        // for循环的工作原理: 使用迭代器
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println(next);
        }

        //迭代本质上是一个串行化的操作, 但外部迭代会将行为和方法混淆

        //2、内部迭代, Stream接口提供了不少操作的方法
        // 这些方法分为 惰性求值方法(不会产生新的集合)、及早求值方法(会从Stream产生值)
        // 区分: 看返回值, 返回 Stream 就是惰性求值方法
        list.stream().forEach(integer -> System.out.println(integer));

        // stream api =========================================================

        //1、of: 有一个列表生成stream流, collect(Collectors.toList()): 变成一个集合
        List<String> strings = Stream.of("a", "b", "c").collect(Collectors.toList());
        List<String> strings1 = Arrays.asList("a", "b", "c");
        System.out.println(strings.equals(strings1));   // true

        //2、map: 映射, 由一个值变成另一个值
        // ("A","B","C")
        strings = strings.stream().map(string -> string.toUpperCase()).collect(Collectors.toList());
        List<String> strings2 = Arrays.asList("A", "B", "C");
        System.out.println(strings.equals(strings2));  //true

        //3、filter: 过滤, 保留符合条件的
        strings = strings.stream()
                .filter(value -> value.equalsIgnoreCase("A"))
                .collect(Collectors.toList());
        List<String> strings3 = Arrays.asList("A");
        System.out.println(strings.equals(strings3));  //true

    }
}
















